/*
 * @Author: _oufen
 * @Date: 2023-07-11 20:23:19
 * @LastEditTime: 2023-07-24 09:16:31
 * @Description:  主要控制模块
 */
/**
 *************************************************************************************************************************
 * @file    control.c
 * @author  oufen
 * @version V1.0
 * @date    2023-07-10
 * @brief   xx模块.c文件配置
 *************************************************************************************************************************
 * @attention
 *
 *
 *************************************************************************************************************************
 */

/* Includes -------------------------------------------------------------------------------------------------------------*/
#include "mycontrol.h"
#include "system.h"
/* 定义 -----------------------------------------------------------------------------------------------------------------*/

Param_InitTypedef Param;
Flag_InitTypedef Flag;

float speed1, speed2; // 测速

uint16_t count_stop; // 接收到库角停止标志

/**
 * @brief 舵机直行的情况
 * @param  None
 * @retval  None
 **/
void Servo_GoLine(void)
{
    // 舵机巡线pid
    if (OpenMv_data1 - 30 < 0) // 说明往右偏
    {
        Param.Line_Out = SERVO_MID_CCR - My_location_pid_control(); // 舵机巡线环输出函数
    }
    else if (OpenMv_data1 - 30 > 0) // 说明往左偏
    {
        Param.Line_Out = SERVO_MID_CCR + My_location_pid_control(); // 舵机巡线环输出函数
    }

    if (Param.Line_Out > SERVO_MAX) // 对舵机进行限幅
    {
        Param.Line_Out = SERVO_MAX;
    }
    else if (Param.Line_Out < SERVO_MIN)
    {
        Param.Line_Out = SERVO_MIN;
    }

    ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, Param.Line_Out);
}

uint32_t pathlenth; // 小车行驶的路程

/**
 * @brief 主控制函数
 * @param  无
 * @retval  无
 **/
void mainControl(void)
{
    static int flag = -1;
    static uint32_t myTime = 0;
    // int speedOut1, speedOut2; // 速度环输出

    switch (flag)
    {
    /*巡线前进  同时寻找库角标志停车*/
    case -1:
        if (OpenMv_data1 != 0) // 只有在接收到OpenMV数据时，电机才开始运动
        {                      // 默认情况
            pid_speed1.target_val = 80;
            pid_speed2.target_val = 80;
            Servo_GoLine();                              // 舵机直行 巡线
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        if (OpenMv_data2 == 0x3A) // 接收到停止标志
        {
            flag = 99;
        }
        break;
        /*往前走一段*/
    case 99:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 打正车轮
        if (pathlenth <= 300)                                      // 小车停止脉冲数   从起点到停止线的脉冲
        {
            // 2200  回正
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 30;
            pid_speed2.target_val = 30;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 0;
        }
        break;
    /*准备打方向  同时向后倒车*/
    case 0:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_LEFT_FIRST_ANGLE); // 打正车轮
        if (pathlenth <= 2450)                                              // 小车停止脉冲数   从起点到停止线的脉冲
        {
            // 2200  回正
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = -30;
            pid_speed2.target_val = -26;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 1;
        }
        break;
    /*车身回正  同时向后倒车  进库*/
    case 1:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 回正车轮
        if (pathlenth <= 2700)                                     // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = -40;
            pid_speed2.target_val = -40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 2;
        }
        // Load_Motor_Pwm(0, 0);                                      // 停止

        // flag = 2;

        break;
        /*进库后停止2s*/
    case 2:
        Load_Motor_Pwm(0, 0);

        if (myTime < 400) // 等待2s
        {
            myTime++;
        }
        else
        {
            myTime = 0;
            flag = 3;
        }

        // if (myTime < 200) // 给舵机一点响应时间  2s
        // {
        //     // buzzer_on();
        //     myTime++;
        //     ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_LEFT_FIRST_ANGLE); // 向左打舵
        // }
        // else
        // if (pathlenth <= 4000)
        // {
        //     ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_LEFT_FIRST_ANGLE); // 向左打舵
        //     // buzzer_off();
        //     pathlenth += (Param.UnitTime_Motor1Pluse + Param.UnitTime_Motor2Pluse); // 累积脉冲
        //     pid_speed1.target_val = 50;
        //     pid_speed2.target_val = 50;
        //     Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
        //     Param.Motor2_PWM_Out = speed2_pid_control();
        //     Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        // }
        // else
        // {
        //     // pathlenth = 0;
        //     myTime = 0;
        //     // flag = 3;
        // }
        break;
    /*挂前进档 前进一段距离*/
    case 3:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 回正车轮
        if (pathlenth <= 1600)                                     // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 40;
            pid_speed2.target_val = 40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 4;
        }
        break;
    /*向右打方向  车身摆正*/
    case 4:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_GO_RIGHT_ANGLE); // 向右打方向
        if (pathlenth <= 2500)                                            // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 40;
            pid_speed2.target_val = 30;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 5;
        }
        break;
        /*出库  巡线  准备  侧方停车*/
    case 5:
        if (OpenMv_data1 != 0)
        {
            pid_speed1.target_val = 80;
            pid_speed2.target_val = 80;
            Servo_GoLine();                              // 舵机直行 巡线
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        if (OpenMv_data2 == 0x3B) // 接收到侧方停止标志
        {
            flag = 6;
        }
        break;
    /*到停止线  停车  然后向后倒一段距离*/
    case 6:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 向右打方向
        if (pathlenth <= 850)                                      // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = -40;
            pid_speed2.target_val = -40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 7;
        }
        break;
        /*开始侧方  先向后倒一段距离*/
    case 7:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_LEFT_FIRST_ANGLE); // 向右打方向
        if (pathlenth <= 1500)                                              // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = -40;
            pid_speed2.target_val = -40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 8;
        }
        break;
        /*打方向   让小车后轮压到库线*/
    case 8:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 向右打方向
        if (pathlenth <= 3500)                                     // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = -40;
            pid_speed2.target_val = -40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 9;
        }
        break;
        /*小车后轮压到库线   再次打方向，打死*/
    case 9:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_GO_Lasr_Angle); // 向右打方向
        if (pathlenth <= 850)                                            // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = -40;
            pid_speed2.target_val = -40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 10;
        }
        break;

        /*摆正车身 */
    case 10:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_CAR_RIGHT); // 向右打方向
        if (pathlenth <= 1000)                                       // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 40;
            pid_speed2.target_val = 40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 11;
        }

        break;
        /*小车进库后 停止两秒 */
    case 11:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 向右打方向
        Load_Motor_Pwm(0, 0);

        if (myTime < 400) // 等待2s
        {
            myTime++;
        }
        else
        {
            myTime = 0;
            flag = 12;
        }

        break;
        /*准备出库   先往后退一会儿*/
    case 12:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 向右打方向
        if (pathlenth <= 800)                                      // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = -40;
            pid_speed2.target_val = -40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 13;
        }

        break;
        /*准备出库   前进 向左打方向*/
    case 13:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, 20000); // 向左打方向
        if (pathlenth <= 1900)                             // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 40;
            pid_speed2.target_val = 40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 14;
        }

        break;
        /*准备出库   前进 回方向*/
    case 14:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 向右打方向
        if (pathlenth <= 700)                                      // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 40;
            pid_speed2.target_val = 40;
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;

            flag = 15;
        }
        break;
        /*出库   前进 向右打死*/
    case 15:
        // Load_Motor_Pwm(0, 0);
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, 37000); // 向右打方向
        if (pathlenth <= 3200)                             // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 40;
            pid_speed2.target_val = 35;
            // Servo_GoLine();
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 16;
        }
        break;
        /*车身摆正*/
    case 16:
        ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR); // 向右打方向
        if (pathlenth <= 800)                                      // 小车停止脉冲数   从起点到停止线的脉冲
        {
            pathlenth += Param.Average_Pluse; // 累积脉冲
            pid_speed1.target_val = 40;
            pid_speed2.target_val = 40;
            // Servo_GoLine();
            Param.Motor1_PWM_Out = speed1_pid_control(); // 速度环输出  期望rpm  120
            Param.Motor2_PWM_Out = speed2_pid_control();
            Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);
        }
        else
        {
            pathlenth = 0;
            flag = 17;
        }
        break;
        /*小车行驶出侧方区域*/
    case 17:
        Load_Motor_Pwm(0, 0);
    }
}

/**
 * @brief   定时器4中断服务函数
 * @param 	无
 * @retval  无
 */
// 具体中断函数对应  函数名在   startup_TM4C123.s 这里调用
void TIMER4A_Handler() // 定时器4中断函数       5ms
{
    // uint8_t flag1 = 0;
    // static uint32_t cnt = 0;

    // cnt++; // 5ms进入一次中断

    // if (cnt >= 200) // 5ms   *200   1s一次进入
    // {
    //   cnt = 0;
    //   flag1 = 1;
    // }

    green_on;

    // 获取单位时间内脉冲数
    Param.UnitTime_Motor1Pluse = Encoder_Get(1);
    Param.UnitTime_Motor2Pluse = Encoder_Get(2);
    // printf("encoder1 = %d,encoder2 = %d\r\n", Param.UnitTime_Motor1Pluse, Param.UnitTime_Motor2Pluse);

    Param.Average_Pluse = MyABS(Param.UnitTime_Motor1Pluse) + MyABS(Param.UnitTime_Motor2Pluse);

    // 获取累积脉冲数
    Param.Sigma_Motor1_Pluse += Param.UnitTime_Motor1Pluse;
    Param.Sigma_Motor2_Pluse += Param.UnitTime_Motor2Pluse;
    // Param.Sigma_Motor1_Pluse += Param.Average_Pluse;
    // Param.Sigma_Motor2_Pluse += Param.Average_Pluse;

    // 3.小车当前行驶的距离  累积脉冲/电机转一圈产生的脉冲  得出多少圈 * 一圈转的距离  -->小车当前行驶的距离
    Param.Current_Motor1_Distance = (((float)Param.Sigma_Motor1_Pluse / (RESOULTION_TOTAL_RATIO * REDUCTION_RATIO)) * (3.14 * 4.6));
    Param.Current_Motor2_Distance = (((float)Param.Sigma_Motor2_Pluse / (RESOULTION_TOTAL_RATIO * REDUCTION_RATIO)) * (3.14 * 4.6));

    // 获取rpm  和滤波后的速度      注意这里是二倍频了 不是四倍频  rpm  = 单位时间脉冲*1000*60  / 13*2*20*5
    // 注意在强制类型转换时  小数后面添加f  防止程序出现warring
    // warring: #1035-D: single-precision operand implicitly converted to double-precision
    speed1 = ((float)Param.UnitTime_Motor1Pluse * 60000.0f) / 2600.0f;
    speed2 = ((float)Param.UnitTime_Motor2Pluse * 60000.0f) / 2600.0f;

    // 主要控制函数
    if (Flag.Start_Flag == 1)
    {
        mainControl();
    }
    // printf("speed1 = %f,speed2 = %f\r\n", speed1, speed2);

    // 速度环 期望rpm
    // pid_speed1.target_val = 110;
    // pid_speed2.target_val = 110;

    // 和循迹结合  串起来   循迹速度闭环
    // pid_speed1.target_val = 180 + PID_output();
    // pid_speed2.target_val = 180 - PID_output();

    // if (pid_speed1.target_val > 200) // 对基础速度进行限幅  防止速度过大
    // {
    //     pid_speed1.target_val = 200;
    // }
    // else if (pid_speed1.target_val < 0)
    // {
    //     pid_speed1.target_val = 0;
    // }

    // if (pid_speed2.target_val > 200)
    // {
    //     pid_speed2.target_val = 200;
    // }
    // else if (pid_speed2.target_val < 0)
    // {
    //     pid_speed2.target_val = 0;
    // }

    // Param.Motor1_PWM_Out = speed1_pid_control();
    // Param.Motor2_PWM_Out = speed2_pid_control();

    // printf("motor1 = %d,motor2 = %d\r\n", Param.Motor1_PWM_Out, Param.Motor2_PWM_Out);  操蛋  会冲突

    // // 舵机巡线pid
    // if (OpenMv_data1 - 30 < 0) // 说明往右偏
    // {
    //     Param.Line_Out = SERVO_MID_CCR - My_location_pid_control(); // 舵机巡线环输出函数
    // }
    // else if (OpenMv_data1 - 30 > 0) // 说明往左偏
    // {
    //     Param.Line_Out = SERVO_MID_CCR + My_location_pid_control(); // 舵机巡线环输出函数
    // }

    // if (Param.Line_Out > SERVO_MAX) // 对舵机进行限幅
    // {
    //     Param.Line_Out = SERVO_MAX;
    // }
    // else if (Param.Line_Out < SERVO_MIN)
    // {
    //     Param.Line_Out = SERVO_MIN;
    // }

    // if (OpenMv_data1 != 0) // 只有在接收到OpenMV数据时，电机才开始运动
    // {
    //     pid_speed1.integral = 0;
    //     pid_speed2.integral = 0;
    //     My_pid_Location.integral = 0;
    //     Load_Motor_Pwm(Param.Motor1_PWM_Out, Param.Motor2_PWM_Out); // 电机装载

    //     ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, Param.Line_Out);
    // }

    // if (OpenMv_data2 == 0x3A) // 接收到库角停止标志  是OpenMV的第二位数据位
    // {
    //     set_motor_disable(); // 失能电机
    //     // 这个函数阻止 PWM 时钟驱动指定发生器模块的定时器/计数器工作
    //     //  pid_speed1.target_val = 0;
    //     //  pid_speed2.target_val = 0;
    //     // Motor_Left_DIR(STOP);
    //     // Motor_Right_DIR(STOP);
    //     // Load_Motor_Pwm(0, 0); // 电机装载
    //     ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_2, SERVO_MID_CCR);
    // }

    ROM_TimerIntClear(TIMER4_BASE, TIMER_TIMA_TIMEOUT); // 中断注销  清除定时器中断标志
}

/**
 * @brief   定时器4初始化
 * @param 	无
 * @retval  无
 */
void Timer4_init(void) // 系统调度定时器初始化
{
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER4); // 定时器4使能

    ROM_TimerConfigure(TIMER4_BASE, TIMER_CFG_PERIODIC); // 32位周期定时器

    ROM_TimerLoadSet(TIMER4_BASE, TIMER_A, ROM_SysCtlClockGet() / 200); // 设定装载值,（80M/200）*1/80M=5ms  80,000,000 /200 /80,000,000 = 5ms 即5ms进入一次中断

    ROM_IntEnable(INT_TIMER4A); // 总中断使能   使能定时器4中断

    ROM_TimerIntEnable(TIMER4_BASE, TIMER_TIMA_TIMEOUT); // 中断输出, 设置模式;  中断4输出 设置模式

    TimerIntRegister(TIMER4_BASE, TIMER_A, TIMER4A_Handler); // 中断函数注册    注册定时器中断的中断处理程序

    /*
    函数原型:
  void  TimerIntRegister(uint32_t ui32Base, uint32_t ui32Timer, void (*pfnHandler)(void))
    参数：
        ui32Base 定时器模块的基地址.
        ui32Timer 指定的定时器; 必须是 TIMER_A, TIMER_B, or TIMER_BOTH 中的一个.
        pfnHandler 指向当发生定时时被调用的函数指针
    说明：
    这个函数注册当发生定时器中断时被调用的中断处理程序。
    此外，这个函数使能中断控制器的全局中断。
    指定的定时器必须使用 TimerIntEnable()函数使能中断。
    调用TimerIntClear()清除中断源是中断处理程序需要做的事情。

    */

    ROM_IntMasterEnable();

    ROM_TimerEnable(TIMER4_BASE, TIMER_A); // 定时器使能开始计数

    ROM_IntPrioritySet(INT_TIMER4A, USER_INT2); // 中断优先级设置  为0x40

    // void IntPrioritySet(uint32_t ui32Interrupt, uint8_t ui8Priority)   ui32Interrupt 指定中断源  ui8Priority   指定中断优先级

    /*
    这个函数设置一个中断的优先级，当多个中断同时有效时，最高优先级的中断先
    于低优先级的中断被处理。较小的优先级数对应较高的优先级。 0 是最高优先级。优
    先级的硬件机制中只是优先级的高 N 位有效 (Tiva C 、 E 系列 N 是 3), 所以所有的优
    先级次序必须在这些位中进行。其余的位能被用作中断源的子优先级，能够在未来的
    器件的硬件优先级机制中使用。 这种安排允许优先级设置转移到不同的 NVIC 中，而无
    需改变中断的总的优先级排列
    */

    // TIMER4A_Handler   这个中断
}
/*****************************************************END OF FILE*********************************************************/
